Complexe getallen in Python: Wiskundige bewerkingen beheersen en poolvorm

In de wereld van wiskunde en wetenschappelijk rekenen zijn complexe getallen fundamenteel. Ze breiden het concept van reële getallen uit door een imaginair component op te nemen, voorgesteld door de eenheid i, waarbij i² = -1. Python, een veelzijdige programmeertaal die wereldwijd wordt gebruikt in industrieën en academische disciplines, biedt robuuste ondersteuning voor complexe getallen, waardoor ingewikkelde wiskundige bewerkingen toegankelijk en efficiënt worden.

Deze uitgebreide handleiding gaat dieper in op de manier waarop Python complexe getallen behandelt, waarbij zowel hun standaard algebraïsche representatie als hun krachtige poolvorm worden verkend. We zullen essentiële wiskundige bewerkingen behandelen en demonstreren hoe je poolcoördinaten kunt gebruiken voor een intuïtiever begrip en manipulatie van complexe getallen in verschillende toepassingen, van signaalverwerking tot kwantummechanica.

Complexe getallen begrijpen in Python

Een complex getal wordt over het algemeen uitgedrukt in rechthoekige (of cartesische) vorm als a + bi, waarbij a het reële deel is en b het imaginaire deel. Python ondersteunt van nature complexe getallen met behulp van deze a + bj notatie, waarbij j wordt gebruikt in plaats van i om verwarring met de huidige context in de elektrotechniek te voorkomen. De complex getal typefuncties van Python werken echter identiek of je nu j of i als imaginaire eenheid in je code gebruikt.

Complexe getallen maken in Python

Het maken van een complex getal in Python is eenvoudig. Je kunt de ingebouwde complex() functie gebruiken of direct de a + bj syntaxis gebruiken.

• De complex() functie gebruiken:

De complex() functie kan twee argumenten aannemen: het reële deel en het imaginaire deel. Als er slechts één argument wordt gegeven, wordt dit behandeld als het reële deel en is het imaginaire deel standaard nul. Als er geen argumenten worden gegeven, maakt het 0j.

            # Complexe getallen maken met complex() 
complex_num1 = complex(3, 5)  # Reëel deel 3, Imaginair deel 5
print(f"Complex getal 1: {complex_num1}")

complex_num2 = complex(7)     # Reëel deel 7, Imaginair deel 0
print(f"Complex getal 2: {complex_num2}")

complex_num3 = complex(0, -2) # Reëel deel 0, Imaginair deel -2
print(f"Complex getal 3: {complex_num3}")

complex_num4 = complex()      # Reëel deel 0, Imaginair deel 0
print(f"Complex getal 4: {complex_num4}")

            

              
                Copy
              
            
          

• De a + bj syntaxis gebruiken:

Dit is de meer gebruikelijke en vaak beter leesbare manier om complexe getallen in Python te definiëren.

            # Complexe getallen maken met een + bj syntaxis
complex_num_a = 4 + 6j
print(f"Complex getal A: {complex_num_a}")

complex_num_b = -2 - 3j
print(f"Complex getal B: {complex_num_b}")

complex_num_c = 9j       # Reëel deel is 0
print(f"Complex getal C: {complex_num_c}")

complex_num_d = 1 + 1j   # Equivalent aan 1 + j
print(f"Complex getal D: {complex_num_d}")

            

              
                Copy
              
            
          

Toegang tot reële en imaginaire delen

Zodra je een complex getalobject hebt, kun je gemakkelijk toegang krijgen tot de reële en imaginaire componenten met behulp van de attributen .real en .imag. Deze attributen retourneren altijd drijvende-kommagetallen.

            my_complex = 5.5 + 2.3j

print(f"Het complexe getal is: {my_complex}")
print(f"Reëel deel: {my_complex.real}")
print(f"Imaginair deel: {my_complex.imag}")

            

              
                Copy
              
            
          

Type complexe getallen

Het complex getal type van Python is verschillend. Je kunt het type controleren met type().

            z = 3 + 4j
print(f"Type van z: {type(z)}")

            

              
                Copy
              
            
          

Wiskundige bewerkingen met complexe getallen in rechthoekige vorm

Python ondersteunt standaard rekenkundige bewerkingen rechtstreeks op complexe getallen, waardoor wiskundige berekeningen intuïtief worden. De resultaten van deze bewerkingen zijn ook complexe getallen.

Optellen en aftrekken

Het optellen of aftrekken van complexe getallen houdt in dat hun overeenkomstige reële en imaginaire delen worden opgeteld of afgetrokken.

Formule:

(a + bi) + (c + di) = (a + c) + (b + d)i

(a + bi) - (c + di) = (a - c) + (b - d)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Optellen
sum_result = z1 + z2
print(f"{z1} + {z2} = {sum_result}")

# Aftrekken
diff_result = z1 - z2
print(f"{z1} - {z2} = {diff_result}")

            

              
                Copy
              
            
          

Vermenigvuldiging

Het vermenigvuldigen van complexe getallen volgt de distributieve eigenschap, waarbij je onthoudt dat j² = -1.

Formule:

(a + bi) * (c + di) = ac + adi + bci + bdi² = (ac - bd) + (ad + bc)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Vermenigvuldiging
prod_result = z1 * z2
print(f"{z1} * {z2} = {prod_result}")

            

              
                Copy
              
            
          

Deling

De deling van complexe getallen houdt in dat de teller en noemer worden vermenigvuldigd met de conjugaat van de noemer om de noemer te rationaliseren.

Formule:

(a + bi) / (c + di) = ((a + bi) * (c - di)) / ((c + di) * (c - di)) = ((ac + bd) + (bc - ad)i) / (c² + d²)

            z1 = 2 + 3j
z2 = 1 - 5j

# Deling
div_result = z1 / z2
print(f"{z1} / {z2} = {div_result}")

# Deling door nul geeft een ZeroDivisionError
# zero_complex = 0 + 0j
# print(z1 / zero_complex)

            

              
                Copy
              
            
          

Conjugaat

De conjugaat van een complex getal a + bj is a - bj. In Python retourneert de methode .conjugate() de complexe conjugaat.

            z = 4 + 7j
conjugate_z = z.conjugate()
print(f"De conjugaat van {z} is {conjugate_z}")

            

              
                Copy
              
            
          

Grootte (absolute waarde)

De grootte of absolute waarde van een complex getal a + bj is de afstand tot de oorsprong in het complexe vlak, berekend als sqrt(a² + b²). De ingebouwde abs() functie van Python berekent dit.

Formule:

|a + bi| = sqrt(a² + b²)

            z = 3 + 4j
magnitude_z = abs(z)
print(f"De grootte van {z} is {magnitude_z}")

            

              
                Copy
              
            
          

Exponentiële macht van complexe getallen

Het verheffen van een complex getal tot een macht wordt ook ondersteund. Voor gehele machten is het eenvoudig. Voor fractionele of complexe machten kunnen de resultaten meerwaardig zijn en worden ze meestal behandeld met behulp van logaritmen.

            z = 1 + 1j

# Kwadrateren van een complex getal
squared_z = z ** 2
print(f"{z} in het kwadraat is {squared_z}")

# Verheffen tot een hogere macht
cubed_z = z ** 3
print(f"{z} tot de derde is {cubed_z}")

# Fractionele macht (kan leiden tot meerdere resultaten)
# Python retourneert meestal de hoofdgrootte
sqrt_z = z ** 0.5
print(f"De vierkantswortel van {z} is (hoofdgrootte) {sqrt_z}")

            

              
                Copy
              
            
          

De kracht van de poolvorm

Hoewel de rechthoekige vorm (a + bj) intuïtief is voor basisrekenkunde, biedt de poolvorm aanzienlijke voordelen voor het begrijpen van rotatie, vermenigvuldiging, deling en exponentiatie, vooral in de techniek en de natuurkunde.

Een complex getal kan ook worden weergegeven in poolvorm als r(cos θ + i sin θ), of compacter met behulp van de formule van Euler, re^iθ. Hier:

• r (modulus): De grootte of afstand tot de oorsprong (hetzelfde als de absolute waarde die eerder is berekend).
• θ (argument): De hoek (in radialen) die het lijnsegment van de oorsprong naar het complexe getal maakt met de positieve reële as.

Converteren van rechthoekig naar poolvorm

Gegeven een complex getal z = a + bj, kunnen we het omzetten naar poolvorm:

• Modulus (r): r = abs(z)
• Argument (θ): θ = atan2(b, a). De functie atan2(y, x) uit de math module (of cmath) is cruciaal omdat deze de hoek in alle vier de kwadranten correct bepaalt, in tegenstelling tot een simpele atan(b/a).

De cmath module van Python biedt functies om direct met poolcoördinaten te werken.

            import cmath

z_rect = 3 + 4j

# Omzetten naar poolcoördinaten
polar_coords = cmath.polar(z_rect)
radius = polar_coords[0]     # Dit is 'r'
angle_radians = polar_coords[1] # Dit is 'theta'

print(f"Rechthoekig: {z_rect}")
print(f"Pool: Radius = {radius:.2f}, Hoek (radialen) = {angle_radians:.2f}")

# Voor graden, converteer radialen naar graden
angle_degrees = cmath.degrees(angle_radians)
print(f"Pool: Hoek (graden) = {angle_degrees:.2f}")

            

              
                Copy
              
            
          

Converteren van poolvorm naar rechthoekige vorm

Gegeven een complex getal in poolvorm r(cos θ + i sin θ) of re^iθ, kunnen we het terug omzetten naar rechthoekige vorm:

• Reëel deel (a): a = r * cos(θ)
• Imaginair deel (b): b = r * sin(θ)

De cmath module van Python heeft de functie cmath.rect() hiervoor.

            import cmath

radius = 5.0
angle_radians = 0.927 # Ongeveer 53.13 graden

# Omzetten van pool- naar rechthoekige coördinaten
rectangular_coords = cmath.rect(radius, angle_radians)

print(f"Pool: Radius = {radius}, Hoek (radialen) = {angle_radians:.2f}")
print(f"Rechthoekig: {rectangular_coords}")

# Het gebruik van graden met cmath.rect is niet direct; converteer eerst graden naar radialen
angle_degrees_example = 45.0
angle_radians_example = cmath.radians(angle_degrees_example)
rect_from_deg = cmath.rect(1.0, angle_radians_example)
print(f"Pool (45 deg): {rect_from_deg}")

            

              
                Copy
              
            
          

Bewerkingen in poolvorm

De echte kracht van de poolvorm komt naar voren bij het uitvoeren van vermenigvuldiging, deling en exponentiatie. Deze bewerkingen worden aanzienlijk eenvoudiger in vergelijking met hun rechthoekige tegenhangers.

Vermenigvuldiging in poolvorm

Om twee complexe getallen in poolvorm te vermenigvuldigen, vermenigvuldig je hun moduli en tel je hun argumenten op.

Formule:

Als z1 = r1(cos θ1 + i sin θ1) en z2 = r2(cos θ2 + i sin θ2), dan

z1 * z2 = (r1 * r2) * [cos(θ1 + θ2) + i sin(θ1 + θ2)]

De cmath module van Python heeft geen directe vermenigvuldigingsfunctie die poolinvoer ontvangt en poolresultaten in één stap uitvoert. Je zou doorgaans moeten converteren naar rechthoekig, vermenigvuldigen en vervolgens terug converteren indien nodig, of handmatig de logica implementeren.

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Converteren naar pool
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Voer vermenigvuldiging uit in het pooldomein
product_r = r1 * r2
product_theta = theta1 + theta2

# Zet het resultaat terug om naar rechthoekig
product_rect_polar_method = cmath.rect(product_r, product_theta)

# Ter vergelijking, directe vermenigvuldiging in rechthoekige vorm
product_rect_direct = z1_rect * z2_rect

print(f"z1 = {z1_rect}, Pool: r={r1:.2f}, theta={cmath.degrees(theta1):.2f} deg")
print(f"z2 = {z2_rect}, Pool: r={r2:.2f}, theta={cmath.degrees(theta2):.2f} deg")
print(f"Product (Poolmethode): {product_rect_polar_method}")
print(f"Product (Directe methode): {product_rect_direct}")

# Opmerking: Kleine drijvende-komma verschillen kunnen optreden

            

              
                Copy
              
            
          

Deling in poolvorm

Om twee complexe getallen in poolvorm te delen, deel je hun moduli en trek je hun argumenten af (argument van de teller minus argument van de noemer).

Formule:

Als z1 = r1(cos θ1 + i sin θ1) en z2 = r2(cos θ2 + i sin θ2), dan

z1 / z2 = (r1 / r2) * [cos(θ1 - θ2) + i sin(θ1 - θ2)]

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Converteren naar pool
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Voer deling uit in het pooldomein
quotient_r = r1 / r2
quotient_theta = theta1 - theta2

# Zet het resultaat terug om naar rechthoekig
quotient_rect_polar_method = cmath.rect(quotient_r, quotient_theta)

# Ter vergelijking, directe deling in rechthoekige vorm
quotient_rect_direct = z1_rect / z2_rect

print(f"Quotient (Poolmethode): {quotient_rect_polar_method}")
print(f"Quotient (Directe methode): {quotient_rect_direct}")

            

              
                Copy
              
            
          

Exponentiatie (Stelling van De Moivre)

Het verheffen van een complex getal in poolvorm tot een gehele macht n wordt vereenvoudigd door de stelling van De Moivre:

Formule:

[r(cos θ + i sin θ)]ⁿ = rⁿ(cos(nθ) + i sin(nθ))

Deze stelling is ongelooflijk handig voor het berekenen van wortels van complexe getallen en het oplossen van polynoomvergelijkingen. Voor complexe machten breidt deze uit met behulp van logaritmen.

            import cmath

z_rect = 1 + 1j

# Converteren naar pool
r, theta = cmath.polar(z_rect)

n = 5  # De macht

# Bereken z^n met behulp van de stelling van De Moivre
hesized_r = r ** n
hesized_theta = n * theta

# Zet het resultaat terug om naar rechthoekig
hesized_rect_polar_method = cmath.rect(hesized_r, hesized_theta)

# Ter vergelijking, directe exponentiatie in Python
hesized_rect_direct = z_rect ** n

print(f"z = {z_rect}, Pool: r={r:.2f}, theta={cmath.degrees(theta):.2f} deg")
print(f"{z_rect}^{n} (Poolmethode): {hesized_rect_polar_method}")
print(f"{z_rect}^{n} (Directe methode): {hesized_rect_direct}")

# Wortels berekenen (bijv. derdemachtswortel, n=1/3)
n_root = 1/3

r_root = r ** n_root
theta_root_principal = n_root * theta

# De hoofdwortel
principal_root = cmath.rect(r_root, theta_root_principal)
print(f"Hoofdderdemachtswortel van {z_rect}: {principal_root}")

# Opmerking: Voor wortels zijn er 'n' verschillende waarden. De stelling van De Moivre direct toegepast
# geeft meestal de hoofdwortel. Om alle wortels te vinden, zou je veelvouden van 2*pi/n aan de hoek moeten toevoegen.

for k in range(3):
    current_angle = (theta + 2 * cmath.pi * k) / 3
    root_k = cmath.rect(r_root, current_angle)
    print(f"Derde machtswortel {k+1}: {root_k}")

            

              
                Copy
              
            
          

Veelvoorkomende complexe getal functies in cmath

De cmath module biedt veel geavanceerde wiskundige functies die werken op complexe getallen, waaronder trigonometrische, hyperbolische en logaritmische functies.

• cmath.sqrt(z): Berekent de vierkantswortel van een complex getal. Retourneert de hoofdkwadraatwortel.
• cmath.exp(z): Berekent e tot de macht z.
• cmath.log(z[, base]): Berekent de logaritme van z. Als base is gespecificeerd, berekent het de logaritme met die basis. Anders berekent het de natuurlijke logaritme.
• cmath.sin(z), cmath.cos(z), cmath.tan(z): Trigonometrische functies voor complexe getallen.
• cmath.sinh(z), cmath.cosh(z), cmath.tanh(z): Hyperbolische functies voor complexe getallen.

            import cmath

z = 1 + 1j

# Vierkantswortel
print(f"sqrt({z}) = {cmath.sqrt(z)}")

# Exponentieel
print(f"exp({z}) = {cmath.exp(z)}")

# Natuurlijke logaritme
print(f"log({z}) = {cmath.log(z)}")

# Sinus
print(f"sin({z}) = {cmath.sin(z)}")

            

              
                Copy
              
            
          

Toepassingen van complexe getallen

Complexe getallen, en hun poolrepresentatie, zijn onmisbaar in tal van wetenschappelijke en technische gebieden:

• Elektrotechniek: Wordt uitgebreid gebruikt in AC-circuitanalyse, impedantie en signaalverwerking. De poolvorm is vanzelfsprekend voor het beschrijven van de grootte en fase van wisselstromen en -spanningen.
• Signaalverwerking: Fourier-transformaties, die signalen ontbinden in hun samenstellende frequenties, vertrouwen sterk op complexe exponenten (e^iωt), die van nature in poolvorm worden uitgedrukt.
• Kwantummechanica: De fundamentele vergelijkingen van de kwantummechanica, zoals de Schrödingervergelijking, omvatten complexe golffuncties.
• Besturingssystemen: Het analyseren van systeemstabiliteit en frequentierespons omvat vaak complexe getallen in het Laplace-domein.
• Vloeistofdynamica: Bepaalde problemen in de vloeistofmechanica kunnen worden vereenvoudigd met behulp van de complexe potentiaaltheorie.
• Fractale geometrie: Fractals zoals de Mandelbrot-verzameling worden gegenereerd door het herhalen van complexe functies.

Globaal voorbeeld: Fourier-transformatie in audioverwerking

Beschouw audio signaalverwerking wereldwijd. Bij het analyseren van een geluidsgolf gebruiken ingenieurs en datawetenschappers de Discrete Fouriertransformatie (DFT) of de efficiënte implementatie ervan, de Fast Fourier Transform (FFT). De DFT zet een tijdsdomeinsignaal (hoe de geluidsdruk in de tijd verandert) om in zijn frequentiedomeinrepresentatie. Deze representatie is een reeks complexe getallen, waarbij elk complex getal overeenkomt met een specifieke frequentie. De grootte van het complexe getal geeft de amplitude (luidheid) van die frequentiecomponent aan en het argument (hoek) geeft de fase aan. Dit maakt taken mogelijk zoals ruisonderdrukking, egalisatie en muzieksynthese, die standaard zijn in de wereldwijde audioproductie en -analyse.

Beste praktijken voor het gebruik van complexe getallen in Python

• Kies de juiste vorm: Voor basisrekenkunde (optellen, aftrekken) is de rechthoekige vorm vaak eenvoudiger. Voor vermenigvuldiging, deling en exponentiatie/wortels, vooral met betrekking tot hoeken en rotaties, is de poolvorm (of het gebruik van cmath functies die dit abstraheren) meestal efficiënter en conceptueel duidelijker.
• Maak gebruik van cmath: Gebruik altijd de cmath module voor complexe getallen wiskunde buiten basisrekenkunde. Het handelt randgevallen af en biedt betrouwbaar geavanceerde functies.
• Let op precisie met drijvende komma: Zoals bij alle drijvende-komma-berekeningen, kunnen resultaten met complexe getallen kleine precisiefouten hebben. Wees voorzichtig bij het vergelijken van complexe getallen voor exacte gelijkheid.
• Begrijp radialen: Trigonometrische functies in de math en cmath modules van Python werken met radialen. Zorg ervoor dat je hoeken in de juiste eenheid staan.
• Gebruik `atan2` voor hoeken: Bij het handmatig berekenen van het argument uit reële en imaginaire delen, gebruik dan math.atan2(imaginaire, reëel) of cmath.phase(complex_number) voor een nauwkeurige kwadrantbepaling.

Conclusie

De ingebouwde ondersteuning van Python voor complexe getallen, aangevuld met de krachtige cmath module, biedt een uitgebreide toolkit voor het aanpakken van een groot aantal wiskundige en wetenschappelijke uitdagingen. Of je nu eenvoudige algebraïsche manipulaties uitvoert of je verdiept in de elegante wereld van poolcoördinaten voor bewerkingen zoals rotatie en schalen, Python geeft je helderheid en efficiëntie.

Door het samenspel tussen rechthoekige en poolvormen te begrijpen en door de functies van de standaardbibliotheek oordeelkundig toe te passen, kunnen ontwikkelaars en onderzoekers wereldwijd nieuwe mogelijkheden ontsluiten in gebieden variërend van telecommunicatie en ruimtevaart tot financieel modelleren en kwantumcomputing. Het beheersen van deze concepten zal ongetwijfeld je probleemoplossend vermogen verbeteren in een steeds complexere en onderling verbonden wereld.